home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Mac Game Programming Gurus / TricksOfTheMacGameProgrammingGurus.iso / More Source / C⁄C++ / FlightSim / plotptsFx.c < prev    next >
C/C++ Source or Header  |  1992-12-11  |  8KB  |  285 lines
  1. #include "flight.h"
  2.  
  3.  
  4. FxVector    fcubes[8] = {{-1, -1, -1}, {1, -1, -1}, {1, 1, -1},
  5. {-1, 1, -1}, {-1, 1, 1}, {-1, -1, 1}, {1, -1, 1}, {1, 1, 1}};
  6.  
  7. Point    Origin = {128, 128};
  8. int        magnify = 0;
  9. FxThreeMatrx    fxRotMatrx;
  10.  
  11.  
  12. /**** Matrix to rotate 3-vector on three axes ****/
  13. FxMkRotMat(Xrot, Yrot, Zrot, matrx)
  14. double Xrot, Yrot, Zrot;
  15. register    FxThreeMatrx matrx;
  16. {
  17.     double cXrot , cYrot , cZrot ;
  18.     double sXrot , sYrot , sZrot ;
  19.  
  20.     cXrot = cos(Xrot);
  21.     cYrot = ldexp(cos(Yrot), magnify);
  22.     cZrot = cos(Zrot);
  23.     sXrot = sin(Xrot);
  24.     sYrot = ldexp(sin(Yrot), magnify);
  25.     sZrot = sin(Zrot);
  26.  
  27.     matrx[0][0] = DToFix(cYrot * cZrot);
  28.     matrx[0][1] = DToFix(cZrot * sXrot * sYrot - ldexp(sZrot * cXrot, magnify));
  29.     matrx[0][2] = DToFix(-(cXrot * cZrot * sYrot + ldexp(sXrot * sZrot, magnify)));
  30.     matrx[1][0] = DToFix(sZrot * cYrot);
  31.     matrx[1][1] = DToFix(sXrot * sYrot * sZrot + ldexp(cXrot * cZrot, magnify));
  32.     matrx[1][2] = DToFix(-sYrot * sZrot * cXrot + ldexp(sXrot * cZrot, magnify));
  33.     matrx[2][0] = DToFix(sYrot);
  34.     matrx[2][1] = DToFix(-sXrot * cYrot);
  35.     matrx[2][2] = DToFix(cXrot * cYrot);
  36. }
  37. /*    matrx[0][0] = cYrot * cZrot
  38.     matrx[0][1] = cZrot * sXrot * sYrot - sZrot * cXrot
  39.     matrx[0][2] = -(cXrot * cZrot * sYrot + sXrot * sZrot)
  40.     matrx[1][0] = sZrot * cYrot
  41.     matrx[1][1] = sXrot * sYrot * sZrot + cXrot * cZrot
  42.     matrx[1][2] = -sYrot * sZrot * cXrot + sXrot * cZrot
  43.     matrx[2][0] = sYrot
  44.     matrx[2][1] = -sXrot * cYrot
  45.     matrx[2][2] = cXrot * cYrot*/
  46.  
  47.  
  48. FracXRotatMatrx(cXrot, sXrot, oMatrx)
  49. Fract    cXrot, sXrot;
  50. register    FracThreeMatrx    oMatrx;
  51. {
  52.     FracThreeMatrx    tMatrx;
  53.  
  54.     tMatrx[0][0] = oMatrx[0][0];
  55.     tMatrx[0][1] = oMatrx[0][1];
  56.     tMatrx[0][2] = oMatrx[0][2];
  57.     tMatrx[1][0] = FracMul(oMatrx[1][0], cXrot) + FracMul(oMatrx[2][0], sXrot);
  58.     tMatrx[1][1] = FracMul(oMatrx[1][1], cXrot) + FracMul(oMatrx[2][1], sXrot);
  59.     tMatrx[1][2] = FracMul(oMatrx[1][2], cXrot) + FracMul(oMatrx[2][2], sXrot);
  60.     tMatrx[2][0] = FracMul(oMatrx[2][0], cXrot) - FracMul(oMatrx[1][0], sXrot);
  61.     tMatrx[2][1] = FracMul(oMatrx[2][1], cXrot) - FracMul(oMatrx[1][1], sXrot);
  62.     tMatrx[2][2] = FracMul(oMatrx[2][2], cXrot) - FracMul(oMatrx[1][2], sXrot);
  63.     *(FracThreeMatrxStrc *)(oMatrx) = *(FracThreeMatrxStrc *)(tMatrx);
  64. }
  65.  
  66. FracYRotatMatrx(cYrot, sYrot, oMatrx)
  67. Fract    cYrot, sYrot;
  68. register    FracThreeMatrx    oMatrx;
  69. {
  70.     FracThreeMatrx    tMatrx;
  71.  
  72.     tMatrx[0][0] = FracMul(oMatrx[0][0], cYrot) - FracMul(oMatrx[2][0], sYrot);
  73.     tMatrx[0][1] = FracMul(oMatrx[0][1], cYrot) - FracMul(oMatrx[2][1], sYrot);
  74.     tMatrx[0][2] = FracMul(oMatrx[0][2], cYrot) - FracMul(oMatrx[2][2], sYrot);
  75.     tMatrx[1][0] = oMatrx[1][0];
  76.     tMatrx[1][1] = oMatrx[1][1];
  77.     tMatrx[1][2] = oMatrx[1][2];
  78.     tMatrx[2][0] = FracMul(oMatrx[0][0], sYrot) + FracMul(oMatrx[2][0], cYrot);
  79.     tMatrx[2][1] = FracMul(oMatrx[0][1], sYrot) + FracMul(oMatrx[2][1], cYrot);
  80.     tMatrx[2][2] = FracMul(oMatrx[0][2], sYrot) + FracMul(oMatrx[2][2], cYrot);
  81.     *(FracThreeMatrxStrc *)(oMatrx) = *(FracThreeMatrxStrc *)(tMatrx);
  82. }
  83.  
  84. FracZRotatMatrx(cZrot, sZrot, oMatrx)
  85. Fract    cZrot, sZrot;
  86. register    FracThreeMatrx    oMatrx;
  87. {
  88.     FracThreeMatrx    tMatrx;
  89.  
  90.     tMatrx[0][0] = FracMul(oMatrx[0][0], cZrot) - FracMul(oMatrx[1][0], sZrot);
  91.     tMatrx[0][1] = FracMul(oMatrx[0][1], cZrot) - FracMul(oMatrx[1][1], sZrot);
  92.     tMatrx[0][2] = FracMul(oMatrx[0][2], cZrot) - FracMul(oMatrx[1][2], sZrot);
  93.     tMatrx[1][0] = FracMul(oMatrx[1][0], cZrot) + FracMul(oMatrx[0][0], sZrot);
  94.     tMatrx[1][1] = FracMul(oMatrx[1][1], cZrot) + FracMul(oMatrx[0][1], sZrot);
  95.     tMatrx[1][2] = FracMul(oMatrx[1][2], cZrot) + FracMul(oMatrx[0][2], sZrot);
  96.     tMatrx[2][0] = oMatrx[2][0];
  97.     tMatrx[2][1] = oMatrx[2][1];
  98.     tMatrx[2][2] = oMatrx[2][2];
  99.     *(FracThreeMatrxStrc *)(oMatrx) = *(FracThreeMatrxStrc *)(tMatrx);
  100. }
  101.  
  102. FractToFixMatrx(srcMat, destMat)
  103. register    FracThreeMatrx srcMat;
  104. register    FxThreeMatrx destMat;
  105. {
  106.     register    int    i, j;
  107.     
  108.     for (i = 0; i < 3; i++)
  109.         for (j = 0; j < 3; j++)
  110.             destMat[i][j] = Frac2Fix(srcMat[i][j]);
  111. }
  112.  
  113. FxTranspMatrx(srcMat, destMat)
  114. register    FracThreeMatrx srcMat;
  115. register    FxThreeMatrx destMat;
  116. {
  117.     register    int    i, j;
  118.     
  119.     for (i = 0; i < 3; i++)
  120.         for (j = 0; j < 3; j++)
  121.             destMat[i][j] = srcMat[j][i];
  122. }
  123.  
  124. FxMatrxMul(mat, vect, resVect)
  125. register    FxThreeMatrx mat;
  126. register    FxVector *vect;
  127. register    FxVector *resVect;
  128. {
  129.     resVect->x = _FixMul(mat[0][0], vect->x) + _FixMul(mat[0][1], vect->y) + _FixMul(mat[0][2], vect->z);
  130.     resVect->y = _FixMul(mat[1][0], vect->x) + _FixMul(mat[1][1], vect->y) + _FixMul(mat[1][2], vect->z);
  131.     resVect->z = _FixMul(mat[2][0], vect->x) + _FixMul(mat[2][1], vect->y) + _FixMul(mat[2][2], vect->z);
  132. }
  133.  
  134. FxMatrxByMatrx(mat1, mat2, resMat)
  135. register    FxThreeMatrx mat1, mat2, resMat;
  136. {
  137.     register    int    i, j;
  138.  
  139.     for(i = 0; i < 3; i++)
  140.         for(j = 0; j < 3; j++)
  141.         {
  142.             resMat[i][j] = _FixMul(mat1[i][0], mat2[0][j])
  143.                 + _FixMul(mat1[i][1], mat2[1][j])
  144.                 + _FixMul(mat1[i][2], mat2[2][j]);
  145.         }
  146. }
  147.  
  148. FxSubtVector(a, b, result)
  149. register    FxVector    *a, *b, *result;
  150. {
  151.     result->x = a->x - b->x;
  152.     result->y = a->y - b->y;
  153.     result->z = a->z - b->z;
  154. }
  155.  
  156. FxAddVector(a, b, result)
  157. register    FxVector    *a, *b, *result;
  158. {
  159.     result->x = a->x + b->x;
  160.     result->y = a->y + b->y;
  161.     result->z = a->z + b->z;
  162. }
  163.  
  164. FxPlotLine(strt, end)
  165. FxVector    *strt, *end;
  166. {
  167.     FxVector     delta;
  168.     FxVector    resStrt, resEnd;
  169.     Boolean    strtFlgs[5], endFlgs[5], done, clipped;
  170. register    int        i;
  171. register    Boolean        noneSet;
  172.  
  173.     delta.x = end->x - strt->x;
  174.     delta.y = end->y - strt->y;
  175.     delta.z = end->z - strt->z;
  176.     resStrt = *strt;
  177.     resEnd = *end;
  178.  
  179.     FxEvalPoint(&resStrt, strtFlgs);
  180.     FxEvalPoint(&resEnd, endFlgs);
  181.  
  182.     done = clipped = FALSE;
  183.     while (NOT(done))
  184.     {
  185.         for (i = 0; i < 5; i++)
  186.             if (strtFlgs[i] AND endFlgs[i])
  187.                 return;
  188.         i = 0;
  189.         while ((i < 4) AND NOT(strtFlgs[i]))
  190.             i++;
  191.         if (i < 4)
  192.         {
  193.             FxPush(&resStrt, &delta, i);
  194.             clipped = TRUE;
  195.             FxEvalPoint(&resStrt, strtFlgs);
  196.         }
  197.         else
  198.         {
  199.             i = 0;
  200.             while ((i < 4) AND NOT(endFlgs[i]))
  201.                 i++;
  202.             if (i < 4)
  203.             {
  204.                 FxNegatVect(&delta);
  205.                 FxPush(&resEnd, &delta, i);
  206.                 FxNegatVect(&delta);
  207.                 clipped = TRUE;
  208.                 FxEvalPoint(&resEnd, endFlgs);
  209.             }
  210.             else
  211.             {
  212.                 FxDraw(&resStrt, &resEnd, clipped);
  213.                 done = TRUE;
  214.             }
  215.         }
  216.     }
  217. }
  218.  
  219. FxNegatVect(theVect)
  220. register    FxVector    *theVect;
  221. {
  222.     theVect->x = -theVect->x;
  223.     theVect->y = -theVect->y;
  224.     theVect->z = -theVect->z;
  225. }
  226.  
  227. FxEvalPoint(theVect, flgArr)
  228. register    FxVector    *theVect;
  229. register    Boolean    flgArr[5];
  230. {
  231.     flgArr[0] = theVect->x > theVect->z;
  232.     flgArr[1] = theVect->z > -theVect->x;
  233.     flgArr[2] = theVect->y > -theVect->x;
  234.     flgArr[3] = theVect->x > theVect->y;
  235.     flgArr[4] = theVect->x >= 0;
  236. }
  237.  
  238. FxPush(theVect, delta, plane)
  239. register    FxVector    *theVect, *delta;
  240. int        plane;
  241. {
  242.     Fixed    t;
  243.  
  244.     switch (plane) {
  245.     case 0:
  246.         t = FixDiv(theVect->z - theVect->x, delta->x - delta->z);
  247.         theVect->x = _FixMul(delta->x, t) + theVect->x;
  248.         theVect->y = _FixMul(delta->y, t) + theVect->y;
  249.         theVect->z = theVect->x;
  250.         break;
  251.     case 1:
  252.         t = FixDiv(-(theVect->x + theVect->z), delta->x + delta->z);
  253.         theVect->x = _FixMul(delta->x, t) + theVect->x;
  254.         theVect->y = _FixMul(delta->y, t) + theVect->y;
  255.         theVect->z = -theVect->x;
  256.         break;
  257.     case 2:
  258.         t = FixDiv(-(theVect->x + theVect->y), delta->x + delta->y);
  259.         theVect->x = _FixMul(delta->x, t) + theVect->x;
  260.         theVect->y = -theVect->x;
  261.         theVect->z = _FixMul(delta->z, t) + theVect->z;
  262.         break;
  263.     case 3:
  264.         t = FixDiv(theVect->x - theVect->y, delta->y - delta->x);
  265.         theVect->x = _FixMul(delta->x, t) + theVect->x;
  266.         theVect->y = theVect->x;
  267.         theVect->z = _FixMul(delta->z, t) + theVect->z;
  268.         break;
  269.     }
  270. }        
  271.     
  272. FxDraw(strt, end, clipped)
  273. register    FxVector        *strt, *end;
  274. Boolean        clipped;
  275. {
  276.     int        strtH, strtV, endH, endV;
  277.  
  278.     strtH = FixToi(FixDiv(strt->y, -strt->x) << 7) + Origin.h;
  279.     strtV = FixToi(FixDiv(-strt->z, -strt->x) << 7) + Origin.v;
  280.     endH = FixToi(FixDiv(end->y, -end->x) << 7) + Origin.h;
  281.     endV = FixToi(FixDiv(-end->z, -end->x) << 7) + Origin.v;
  282.  
  283.     MoveTo(strtH, strtV);
  284.     LineTo(endH, endV);
  285. }